Artificial Intelligence Nanodegree¶
Project: Dog Breed Identification App using CNNs and PyTorch¶
Why We're Here¶
In this notebook, you will make the first steps towards developing an algorithm that could be used as part of a mobile or web app. At the end of this project, your code will accept any user-supplied image as input. If a dog is detected in the image, it will provide an estimate of the dog's breed. If a human is detected, it will provide an estimate of the dog breed that is most resembling. The image below displays potential sample output of your finished project (... but we expect that each student's algorithm will behave differently!).
In this real-world setting, you will need to piece together a series of models to perform different tasks; for instance, the algorithm that detects humans in an image will be different from the CNN that infers dog breed. There are many points of possible failure, and no perfect algorithm exists. Your imperfect solution will nonetheless create a fun user experience!
We mention that the task of assigning breed to dogs from images is considered exceptionally challenging. To see why, consider that even a human would have great difficulty in distinguishing between a Brittany and a Welsh Springer Spaniel.
| Brittany | Welsh Springer Spaniel |
|---|---|
 |
 |
It is not difficult to find other dog breed pairs with minimal inter-class variation (for instance, Curly-Coated Retrievers and American Water Spaniels).
| Curly-Coated Retriever | American Water Spaniel |
|---|---|
 |
 |
Likewise, recall that labradors come in yellow, chocolate, and black. Your vision-based algorithm will have to conquer this high intra-class variation to determine how to classify all of these different shades as the same breed.
| Yellow Labrador | Chocolate Labrador | Black Labrador |
|---|---|---|
 |
 |
 |
We also mention that random chance presents an exceptionally low bar: setting aside the fact that the classes are slightly imabalanced, a random guess will provide a correct answer roughly 1 in 133 times, which corresponds to an accuracy of less than 1%.
Extra Challenge (PyTorch)¶
As an extra challenge, I decided to build this project in PyTorch. The original Udacity project was done in Keras. This is my very first exposure to PyTorch, so please bear with me. Most of the PyTorch specific code below was written using this tutorial as a guide. I will post some lessons learned in the README.md.
The Road Ahead¶
We break the notebook into separate steps. Feel free to use the links below to navigate the notebook.
- Step 1: Import & Explore Data
- Step 2: Generate Datasets
- Step 3: Create a CNN to Classify Dog Breeds (using Transfer Learning)
- Step 4: Inference: Use Model to Make Predictions
- Step 5: Incorporate Model into Human-Dog Detection Algorithm
import copy
import cv2
from glob import glob
from io import open
import json
import matplotlib.image as mpimg
import matplotlib.pyplot as plt
import numpy as np
import os, os.path, random
from PIL import Image
import requests
import shutil
import time
import torch
from torch.autograd import Variable
import torch.functional as F
import torch.nn as nn
import torch.optim as optim
from torch.optim import lr_scheduler
import torchvision
from torchvision import datasets, models, transforms
plt.ion() # interactive mode
%matplotlib inline
Step 1: Import and Explore Data¶
In the code cell below, we import a dataset of dog images. See the project instructions page for links to download the data files. Once setup, our images directory should looks like this:
project_folder
__dogImages
____train
______class_breed
________dog_img_a.jpg
________dog_img_b.jpg
____val
______class_breed
________dog_img_c.jpg
________dog_img_d.jpg
____test
______class_breed
________dog_img_e.jpg
________dog_img_f.jpgNOTE: The validation subdirectory must be renamed from "valid" to "val" in order to work with the PyTorch dataloader, specifically the datasets.ImageFolder method.
Now that our dogImages directory is setup, we should familiarize ourself with the data. I did this as part of a separate notebook, dog-breed-data-exploration.ipynb.
Normalization and Augmentation¶
In the cell below, we setup our data_transforms, where we define the normalization and augmentation steps we want to perform on the data. Note that all augmentations (beyond resizing) are only performed on the training set.
Also, since we'll use transfer learning of pre-trained models in PyTorch, we should align our normalization settings with these models. See here for reference.
# All images are resized to 224x224 and normalized
# Only training images receive further augmentation
data_transforms = {
'train': transforms.Compose([
transforms.Resize(256),
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.RandomAffine(degrees=5, translate=(0.1, 0.1), scale=(1.0, 1.1), shear=5, resample=False, fillcolor=0),
transforms.RandomApply([transforms.ColorJitter(brightness=0.1, contrast=0.1, saturation=0.1, hue=0.1)], p=0.5),
transforms.RandomGrayscale(p=0.2),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
]),
'val': transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
]),
'test': transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
]),
}
Generate datasets for Training, Validation, and Testing¶
Now we'll iterate through the data and apply the transforms outlined above.
One thing to notice here is the way the class label data is automatically derived using the torchvision.datasets.ImageFolder method. This is a very handy tool. One nice feature of this method is that we don't need to one-hot encode our labels. It builds an index of class labels from the names of the subdirectories in the train/val/test folders. So you don't need to manually import the classes.
However, note that the class IDs are automatically assigned by PyTorch and therefore might be different than the original class IDs that were assigned to each dog breed as part of the original project in Keras. Rather than try to remove these old class IDs from the subdirectory folder names, I decided to simply ignore them and just rely on the index generated through Torchvision.
data_dir = 'dogImages'
image_datasets = {x: datasets.ImageFolder(os.path.join(data_dir, x),
data_transforms[x])
for x in ['train', 'val', 'test']}
dataloaders = {x: torch.utils.data.DataLoader(image_datasets[x], batch_size=4,
shuffle=True, num_workers=4)
for x in ['train', 'val', 'test']}
dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'val', 'test']}
class_names = image_datasets['train'].classes
n_classes = len(class_names)
#Check if gpu support is available
cuda_avail = torch.cuda.is_available()
device = torch.device("cuda:0" if cuda_avail else "cpu")
print("Device:", device)
print(f"No. of Training Records: {dataset_sizes['train']}")
print(f"No. of Validation Records: {dataset_sizes['val']}")
print(f"No. of Testing Records: {dataset_sizes['test']}")
# Preview the set of class labels (i.e. dog breeds)
# -- again, note that the old class IDs are included in the labels. This is a carryover from the original project,
# -- which was setup for Keras. We'll leave the IDs for now and split them out later during the inference step.
print(f"No. of Classes: {n_classes}")
class_names
# Preview a record (input, label) from the training set.
# -- Image pixel values should be normalized. Label value should be an integer between 0 and 133.
dataloaders['train'].dataset[1500]
Visualize Image Transformations¶
Let’s visualize a few training images to make sure the data augmentations are in-line with our expectations.
def imshow(inp, title=None):
inp = inp.numpy().transpose((1, 2, 0))
mean = np.array([0.5, 0.5, 0.5])
std = np.array([0.5, 0.5, 0.5])
inp = std * inp + mean
inp = np.clip(inp, 0, 1)
fig = plt.figure(figsize=(12,3))
plt.axis('off')
plt.imshow(inp)
if title is not None:
plt.title(title)
plt.pause(0.001) # pause a bit so that plots are updated
# Get a batch of training data
inputs, classes = next(iter(dataloaders['train']))
# Make a grid from batch
out = torchvision.utils.make_grid(inputs)
imshow(out, title=[class_names[x] for x in classes])
We can observe the various perturbations in the images above. To the naked eye, they seem to make sense. We see different shifts in translation, cropping, rotation, brightness, color, etc. However, none of the transformations overly distort the image to the point where the dog breed can't be recognized. These augmentations should help our model generalize and reduce overfitting. I love how easily this can be done in PyTorch.
Step 3: Create a CNN to Classify Dog Breeds (using Transfer Learning)¶
Now we use transfer learning to create a CNN that can identify dog breeds from images. The goal for the Udacity project is to attain at least 60% accuracy on the test set.
Training Loop¶
def train_model(model, criterion, optimizer, scheduler, num_epochs=25):
since = time.time()
best_model_wts = copy.deepcopy(model.state_dict())
best_acc = 0.0
for epoch in range(num_epochs):
print('Epoch {}/{}'.format(epoch+1, num_epochs))
print('-' * 10)
# Each epoch has a training and validation phase
for phase in ['train', 'val']:
if phase == 'train':
scheduler.step()
model.train() # Set model to training mode
else:
model.eval() # Set model to evaluate mode
running_loss = 0.0
running_corrects = 0
# Iterate over data.
for inputs, labels in dataloaders[phase]:
inputs = inputs.to(device)
labels = labels.to(device)
# zero the parameter gradients
optimizer.zero_grad()
# forward
# track history if only in train
with torch.set_grad_enabled(phase == 'train'):
outputs = model(inputs)
_, preds = torch.max(outputs, 1)
loss = criterion(outputs, labels)
# backward + optimize only if in training phase
if phase == 'train':
loss.backward()
optimizer.step()
# statistics
running_loss += loss.item() * inputs.size(0)
running_corrects += torch.sum(preds == labels.data)
epoch_loss = running_loss / dataset_sizes[phase]
epoch_acc = running_corrects.double() / dataset_sizes[phase]
print('{} Loss: {:.4f} | Acc: {:.4f}'.format(
phase, epoch_loss, epoch_acc))
# deep copy the model
if phase == 'val' and epoch_acc > best_acc:
best_acc = epoch_acc
best_model_wts = copy.deepcopy(model.state_dict())
torch.save(model.state_dict(), "saved_models/resnet18_model_{}.ckpt".format(epoch+1))
print("Checkpoint saved")
print()
time_elapsed = time.time() - since
print('Training complete in {:.0f}m {:.0f}s'.format(
time_elapsed // 60, time_elapsed % 60))
print('Best val Acc: {:4f}'.format(best_acc))
# load best model weights
model.load_state_dict(best_model_wts)
return model
Load Pre-trained Model and Replace Last Fully Connected Layer¶
You can choose from a handful of pre-trained models in PyTorch. The complete list is available here. I decided to stick with ResNet, since that's what's used in PyTorch's transfer learning tutorial.
NOTE: I'm just following the tutorial code verbatim here, and I was surprised that a softmax activation was not applied to the final layer (as is commonly done in Keras). This would give us a probabality distribution that indidcates the model's confidence of the predicted breeds for a given input image. I tried to get softmax working at this point in pipeline, but was unsuccessful. So, instead, I decided to apply it downstream to the outputs during inference.
model_ft = models.resnet50(pretrained=True)
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, n_classes)
model_ft = model_ft.to(device)
Setup Optimization, Regularization, and Loss Functions¶
# Loss function
criterion = nn.CrossEntropyLoss()
# Optimization + learning rate. Note that all parameters are being optimized.
optimizer_ft = optim.SGD(model_ft.parameters(), lr=0.001, momentum=0.9)
# Regularization. Decay LR by a factor of 0.1 every 7 epochs
exp_lr_scheduler = lr_scheduler.StepLR(optimizer_ft, step_size=7, gamma=0.1)
# Fix for cuda error resulting from truncated images
# https://stackoverflow.com/a/23575424/7434289
from PIL import ImageFile
ImageFile.LOAD_TRUNCATED_IMAGES = True
# Run the training loop
model_ft = train_model(model_ft, criterion, optimizer_ft, exp_lr_scheduler,
num_epochs=20)
IMPORTANT :¶
If you encounter this error, RuntimeError: cuda runtime error (59) : device-side assert triggered you may have a mismatch in the expected number of classes (i.e. the number of output nodes in your last fc layer must equal the number of classes in your target data). Once you correct this in the code, you need to restart the kernel and re-run all of the notebook cells. Here is a link describing the issue.
Visualize Model Results¶
Before going any further, let's visualize a sample of the model output to make sure the predictions make sense.
def visualize_model(model, num_images=3):
was_training = model.training
model.eval()
images_so_far = 0
fig = plt.figure(figsize=(16,4))
with torch.no_grad():
for i, (inputs, labels) in enumerate(dataloaders['val']):
inputs = inputs.to(device) # occasionally commented this out to resolve device mismatch error
labels = labels.to(device) # occasionally commented this out to resolve device mismatch error
outputs = model(inputs)
_, preds = torch.max(outputs, 1)
for j in range(inputs.size()[0]):
images_so_far += 1
inp = inputs.cpu().data[j]
inp = inp.numpy().transpose((1, 2, 0))
mean = np.array([0.485, 0.456, 0.406])
std = np.array([0.229, 0.224, 0.225])
inp = std * inp + mean
inp = np.clip(inp, 0, 1)
ax = fig.add_subplot(1, 3, images_so_far)
ax.imshow(inp.squeeze(), cmap="gray", interpolation='nearest')
plt.title('predicted: {}'.format(class_names[preds[j]]))
plt.axis('off')
if images_so_far == num_images:
model.train(mode=was_training)
return
plt.show()
model.train(mode=was_training)
visualize_model(model_ft)
visualize_model(model_ft)
visualize_model(model_ft)
Our initial model predictions look good so far!
Test Accuracy¶
def test_acc(test_set, model):
'''Calculates accuracy. Takes as input a PyTorch dataloader object containing images and labels.'''
model.eval()
test_acc = 0.0
running_corrects = 0
# Iterate over data
for inputs, labels in test_set:
inputs = inputs.to(device) # occasionally commented this out to resolve device mismatch error
labels = labels.to(device) # occasionally commented this out to resolve device mismatch error
outputs = model(inputs)
_, preds = torch.max(outputs, 1)
running_corrects += torch.sum(preds == labels.data)
test_acc = running_corrects.double() / len(test_set.dataset)
print('Acc: {:.2f}%'.format(test_acc*100))
return test_acc
test_acc(dataloaders['test'], model_ft)
Although we won't be winning any Kaggle competitions, our accuracy still looks good!
Step 4: Inference — Use Model to Make Predictions
In this step, we use the best-performing version of our model to make dog breed predictions. Normally you'd use completely new images for this step, but I decided to use the tet images in order to save time. We'll perform true inference on new images in the final step.
# Instantiate model, load weights, and set model to evaluation mode
model_ft = models.resnet50(pretrained=True)
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, n_classes)
model_ft = model_ft.to(device)
checkpoint = torch.load('saved_models/resnet18_model_14.ckpt')
model_ft.load_state_dict(checkpoint)
model_ft.eval()
Make Predictions¶
This function takes an image path and returns the top 3 predicted breeds. Notice that this is where we now apply softmax in order to get a probability distribution, which we use to represent the model's level of confidence in its predictions.
def predict_breed(image_path, model):
'''Predicts the top 3 most likely breeds for a given image.'''
image = Image.open(image_path)
# Define transformations for the image
transformation = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])
# Preprocess the image
image_tensor = transformation(image).float()
# Add an extra batch dimension since pytorch treats all images as batches
image_tensor = image_tensor.unsqueeze_(0)
image_tensor = image_tensor.to(device)
# Turn the input into a Variable
input = Variable(image_tensor)
# Return the top predictions and confidence scores
output = model(input)
softmax = nn.Softmax(dim=1)
preds = softmax(output)
top_preds = torch.topk(preds, 3)
pred_breeds = [class_names[i] for i in top_preds[1][0]]
confidence = top_preds[0][0]
return pred_breeds, confidence
test_img_path = 'dogImages/test/047.Chesapeake_bay_retriever/Chesapeake_bay_retriever_03361.jpg'
predict_breed(test_img_path, model_ft)
Our test prediction was correct with 99% certainty!
Display Predictions¶
Now let's look at dog breed predictions for a set of test images.
# Create list of test image paths
test_img_paths = sorted(glob('dogImages/test/*/*'))
# Shuffle the list and display first few rows
np.random.shuffle(test_img_paths)
test_img_paths[0:5]
def display_predictions(img_paths, model):
for img_path in img_paths:
print("What's up DOG?!")
# display test image
_, ax = plt.subplots()
img = mpimg.imread(img_path)
_ = ax.imshow(img)
plt.axis('off')
plt.show()
# extract breed from image path
actual_breed = img_path.split('/')[2].split('.')[1]
print(f"Actual Breed: {actual_breed}\n")
# display breeds and confidence scores
breeds, confidence = predict_breed(img_path, model)
predictions = ""
for breed, conf in zip(breeds, confidence):
if conf > 0.005:
predictions += f" - {breed.split('.')[1]} ({(conf*100):.0f}%)\n"
print(f"Predicted Breed (confidence):\n{predictions}")
# display sample of matching breed images
fig = plt.figure(figsize=(16,4))
for i, breed in enumerate(breeds):
subdir = '/'.join(['dogImages/val', breed])
file = random.choice(os.listdir(subdir))
path = '/'.join([subdir, file])
img = mpimg.imread(path)
ax = fig.add_subplot(1,3,i+1)
ax.imshow(img.squeeze(), cmap="gray", interpolation='nearest')
plt.title(breed.split('.')[1])
plt.axis('off')
plt.show()
print("\n"*3)
# Test algorithm on images provided in 'test' directory. Make predictions for each image. And show an example
# for each prediction.
display_predictions(test_img_paths[0:15], model_ft)
We can see from the results above that the predictions are quite accurate, with a few breeds being correctly predicted with 100% confidence. However, the model still struggles to differentiate certain breeds, such as Giant Schnauzer vs. Kerry Blue Terrier vs. Bouvier des Flandres.
Create a Human Face Detector¶
Here we use OpenCV's implementation of Haar feature-based cascade classifiers to detect human faces in images. OpenCV provides many pre-trained face detectors, stored as XML files on github. Udacity has already downloaded one of these detectors and stored it in the haarcascades directory.
In the next code cell, we demonstrate how to use this detector to find human faces in a sample image.
import random
random.seed(8675309)
# load filenames in shuffled human dataset
human_files = np.array(glob("lfw/*/*"))
random.shuffle(human_files)
human_files_short = human_files[:100]
# print statistics about the dataset
print('There are %d total human images.' % len(human_files))
# extract pre-trained face detector
face_cascade = cv2.CascadeClassifier('haarcascades/haarcascade_frontalface_alt.xml')
# load color (BGR) image
img = cv2.imread(human_files[19])
# convert BGR image to grayscale
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# find faces in image
faces = face_cascade.detectMultiScale(gray)
# print number of faces detected in the image
print('Number of faces detected:', len(faces))
# get bounding box for each detected face
for (x,y,w,h) in faces:
# add bounding box to color image
cv2.rectangle(img,(x,y),(x+w,y+h),(66,244,92),3)
# convert BGR image to RGB for plotting
cv_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
# display the image, along with bounding box
plt.imshow(cv_rgb)
plt.axis('off')
plt.show()
Before using any of the face detectors, it is standard procedure to convert the images to grayscale. The detectMultiScale function executes the classifier stored in face_cascade and takes the grayscale image as a parameter.
In the above code, faces is a numpy array of detected faces, where each row corresponds to a detected face. Each detected face is a 1D array with four entries that specifies the bounding box of the detected face. The first two entries in the array (extracted in the above code as x and y) specify the horizontal and vertical positions of the top left corner of the bounding box. The last two entries in the array (extracted here as w and h) specify the width and height of the box.
We can use this procedure to write a function that returns True if a human face is detected in an image and False otherwise. This function, aptly named face_detector, takes a string-valued file path to an image as input and appears in the code block below.
# Returns "True" if face is detected in image stored at img_path
def face_detector(img_path):
img = cv2.imread(img_path)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
faces = face_cascade.detectMultiScale(gray)
return len(faces) > 0
Assess the Face Detector¶
import random
random.seed(8675309)
# load filenames in shuffled dog dataset
dog_files = np.array(glob("dogImages/train/*/*"))
random.shuffle(dog_files)
dog_files_short = dog_files[:100]
# print statistics about the dataset
print('There are %d total dog images.' % len(dog_files))
# Test the performance of the face_detector algorithm
# on the images in human_files_short and dog_files_short.
human_detections = np.sum([face_detector(img) for img in human_files_short])
dog_detections = np.sum([face_detector(img) for img in dog_files_short])
print('face detection in human image set = {}%'.format(human_detections))
print('face detection in dog image set = {}%'.format(dog_detections))
It appears our face detector works quite well. However, it seems that we have some pictures with both dogs and humans in them.
Final Step: Incorporate into Single Algorithm¶
Write an algorithm that accepts a file path to an image and first determines whether the image contains a human, dog, or neither. Then,
- if a dog is detected in the image, return the predicted breed.
- if a human is detected in the image, return the resembling dog breed.
- if neither is detected in the image, provide output that indicates an error.
You are welcome to write your own functions for detecting humans and dogs in images, but feel free to use the face_detector function developed above. You are required to use your CNN from Step 4 to predict dog breed.
Some sample output for our algorithm is provided below, but feel free to design your own user experience!
# Create list of image paths to feed into classification algorithm
def create_img_paths(img_dir):
'''Generates a list of paths for all images within a given directory.'''
# image directory and valid extensions
image_path_list = []
valid_image_extensions = [".jpg", ".jpeg", ".png", ".tif", ".tiff"]
valid_image_extensions = [item.lower() for item in valid_image_extensions]
# create a list of all files in directory and append names with a valid extention
for file in os.listdir(img_dir):
extension = os.path.splitext(file)[1]
if extension.lower() not in valid_image_extensions:
continue
image_path_list.append(os.path.join(img_dir, file))
return image_path_list
# Pull everything together into a single algorithm
def human_dog_predictor(img_path, model):
'''Detects whether an image contains a human or a dog. If the image contains a dog, the
most likely breeds are returned. If the image contains a human, the closest resembling dog
breeds are returned.'''
breeds, confidence = predict_breed(img_path, model)
_, ax = plt.subplots()
if confidence[0] > 0.3:
print("What's up DOG?!")
# display test image
img = mpimg.imread(img_path)
_ = ax.imshow(img)
plt.axis('off')
plt.show()
# display breeds and confidence scores
predictions = ""
for breed, conf in zip(breeds, confidence):
if conf > 0.005:
predictions += f" - {breed.split('.')[1]} ({(conf*100):.0f}%)\n"
print(f"Predicted Breed (confidence):\n{predictions}")
# display sample of matching breed images
fig = plt.figure(figsize=(16,4))
for i, breed in enumerate(breeds):
subdir = '/'.join(['dogImages/val', breed])
file = random.choice(os.listdir(subdir))
path = '/'.join([subdir, file])
img = mpimg.imread(path)
ax = fig.add_subplot(1,3,i+1)
ax.imshow(img.squeeze(), cmap="gray", interpolation='nearest')
plt.title(breed.split('.')[1])
plt.axis('off')
plt.show()
elif face_detector(img_path):
print("Hey there HUMAN!")
# display image
img = mpimg.imread(img_path)
_ = ax.imshow(img)
plt.axis('off')
plt.show()
# display resembling breeds
resemblance = ""
for breed, conf in zip(breeds, confidence):
resemblance += f" - {breed.split('.')[1]}\n"
print(f"Most Resembled Breeds:\n{resemblance}")
# display sample of matching breed images
fig = plt.figure(figsize=(16,4))
for i, breed in enumerate(breeds):
subdir = '/'.join(['dogImages/val', breed])
file = random.choice(os.listdir(subdir))
path = '/'.join([subdir, file])
img = mpimg.imread(path)
ax = fig.add_subplot(1,3,i+1)
ax.imshow(img.squeeze(), cmap="gray", interpolation='nearest')
plt.title(breed.split('.')[1])
plt.axis('off')
plt.show()
else:
print("Hmm. I can't determine what you are. ¯\_(ツ)_/¯")
img = mpimg.imread(img_path)
_ = ax.imshow(img)
plt.axis('off')
plt.show()
print("\n"*3)
Test your Algorithm¶
In this section, you will take your new algorithm for a spin! What kind of dog does the algorithm think that you look like? If you have a dog, does it predict your dog's breed accurately? If you have a cat, does it mistakenly think that your cat is a dog?
Test your algorithm at least six images on your computer. Feel free to use any images you like. Use at least two human and two dog images.
# Test algorithm on images provided in '/images' directory. Make predictions for each image. And show an example
# for each prediction.
img_dir = 'images/test_images'
sample_images = create_img_paths(img_dir)
for img_path in sample_images:
human_dog_predictor(img_path, model_ft)
